#!/usr/bin/env python
# -*-coding: utf-8 -*-
# Filename: configurar_reporte.py

##
# Módulos del sistema
try:
    import pygtk
    pygtk.require("2.0")
    import gtk
    import gtk.glade
except ImportError, error:
    print error
    print "Necesitas la librería gráficas gtk+pygtk"

##
# Módulos propios
try:
    from lib.funciones_utiles import close, add_find_column
    from lib.database import Ticket
    from gui.msj_retroalimentacion import MensajeDeError
except ImportError, error:
    print error
    print "Error en configurar_reporte.py"


class ConfigurarReporte:
    def __init__(self, padre, lista_ticket=None):
        self.gladefile = "gui/ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile, "ConfigurarReporte")
        self.window = self.wTree.get_widget("ConfigurarReporte")
        self.un_dict = {"on_button62_clicked": self.configurar_reporte,
                "on_button63_clicked": self.close,
                "on_button67_clicked": self.close,
                "on_button66_clicked": self.aceptar,
                "on_button65_clicked": self.imprimir,
                "on_button64_clicked": self.detalle_ticket,
                "on_radiobutton2_toggled": self.armar_lista_ticket,
                "on_radiobutton1_toggled": self.armar_lista_legajo,
                "on_radiobutton14_toggled": self.armar_lista_estado,
                "on_radiobutton15_toggled": self.armar_lista_grupo,
                "on_radiobutton16_toggled": self.armar_lista_clasificacion,
                "on_button112_clicked": self.agregar_secuencia,
                "on_button113_clicked": self.quitar_secuencia}
        self.wTree.signal_autoconnect(self.un_dict)
        self.window.resize(350, 200)
        # Varibles:
        # self.criterio == self.criterios_de_ordenamiento
        # self.secuencia == self.secuencia_de_ordenamiento
        self.padre = padre
        self.lista_ticket = lista_ticket
        self.vbox_62 = self.wTree.get_widget("vbox62")
        self.hbox_152 = self.wTree.get_widget("hbox152")# Listas de criterios
        self.hbox_116 = self.wTree.get_widget("hbox116")
        self.hbox_110 = self.wTree.get_widget("hbox110")
        # Formas de agrupacion
        self.radio_ticket = self.wTree.get_widget("radiobutton2")
        self.radio_legajo = self.wTree.get_widget("radiobutton1")
        self.radio_estado = self.wTree.get_widget("radiobutton14")
        self.radio_grupo = self.wTree.get_widget("radiobutton15")
        self.radio_clasificacion = self.wTree.get_widget("radiobutton16")
        # Orden
        self.radio_ascendente = self.wTree.get_widget("radiobutton17")
        self.radio_descendente = self.wTree.get_widget("radiobutton18")
        self.tree_criterio = self.wTree.get_widget("treeview29")
        self.tree_secuencia = self.wTree.get_widget("treeview30")
        self.lista_criterio = gtk.ListStore(str)
        self.lista_secuencia = gtk.ListStore(str)
        self.tree_criterio.set_model(self.lista_criterio)
        self.tree_secuencia.set_model(self.lista_secuencia)
        # Utilidades
        self.iterador_criterio = {}
        self.iterador_secuencia = {}
        self.criterios = []
        self.secuencia = []
        # Tree resultado
        self.tree_resultado = self.wTree.get_widget("treeview16")
        self.armar_listas_criterios()

    def armar_listas_criterios(self):
        """Armará la cabecera de la lista criterios y secuencia"""
        trees = (self.tree_criterio, self.tree_secuencia)
        for tree in trees:
            add_find_column("Nombre", 0, tree)

    def variables_a_cero(self):
        """Setea los iteradores y las listas a sus valores default"""
        self.iterador_criterio = {}
        self.iterador_secuencia = {}
        self.lista_criterio.clear()
        self.lista_secuencia.clear()
        self.criterios = []
        self.secuencia = []

    def armar_lista_estado(self, widget):
        if self.radio_estado.get_active():
            self.variables_a_cero()
            criterios = ("Nro. Ticket", "Clasificacion actual",
                    "Fecha de Apertura", "Tiempo Acumulado total de atención")
            self.armar_criterios(criterios)
            self.hbox_152.show()
            print "Criterios Estado"
            print self.criterios

    def armar_criterios(self, criterios):
        """Arma la lista de criterios con la lista de criterios pasada"""
        for criterio in criterios:
            self.iterador_criterio[criterio]=self.lista_criterio.append([criterio])
            self.criterios.append(criterio)

    def armar_lista_grupo(self, widget):
        if self.radio_grupo.get_active():
           self.variables_a_cero()
           criterios = ("Nro. Ticket", "Clasificacion actual de ticket",
                   "Estado Actual", "Fecha de Apertura")
           self.armar_criterios(criterios)
           self.hbox_152.show()
           print "Criterios Grupo de Resolucion"
           print self.criterios

    def armar_lista_clasificacion(self, widget):
        if self.radio_clasificacion.get_active():
            self.variables_a_cero()
            criterios = ("Nro. Ticket", "Legajo", "Estado Actual",
                    "Fecha de Apertura", "Grupo Actual de Resolucion")
            self.armar_criterios(criterios)
            self.hbox_152.show()
            print "Criterios Clasificacion: "
            print self.criterios

    def armar_lista_ticket(self, widget):
        if self.radio_ticket.get_active():
            self.hbox_152.hide()
            self.window.resize(350, 200)

    def armar_lista_legajo(self, widget):
        """Al armar los iteradores guardo como clave el criterio y como valor
        el gtk.iter, para asi a la hora de remover ese mismo de la lista ya
        tengo el iterador.
        """
        self.hbox_152.show()
        if self.radio_legajo.get_active():
            self.variables_a_cero()
            print "Lista Legajo\n---------"
            criterios = ("Nro Ticket.", "Estado actual",
                "Fecha de Ultimo cambio", "Ultimo Grupo de Resolucion",
                "Clasificacion actual", "Fecha de Apertura")
            self.armar_criterios(criterios)
            print "Criterios de Legajo"
            print self.criterios
            self.hbox_152.show()
    
    def criterio_seleccionado(self, tree):
        """Consulta si esta seleccionado un elemento del tree pasado"""
        model, path = tree.get_selection().get_selected_rows()
        if path:
            pos, = path[0]
            return pos, True
        else:
            return "", False

    def agregar_secuencia(self, widget):
        """Agregara la lista de secuencia un criterio de ordenamiento"""
        pos, seleccionado = self.criterio_seleccionado(self.tree_criterio)
        if seleccionado:
            # Pasamos el criterio a la derecha y lo eliminamos
            criterio = self.criterios[pos]
            self.secuencia.append(criterio)
            self.iterador_secuencia[criterio] = self.lista_secuencia.append(
                    [criterio])
            self.lista_criterio.remove(self.iterador_criterio[criterio])
            self.criterios.remove(criterio)
            self.rearmar_criterios()
        else:
            texto = ["Debe seleccionar el criterio que quiere agregar a la",
                    "lista de Secuencia de ordenamiento."]
            msj = MensajeDeError("\n".join(texto), self.window)
            msj.run()

    def rearmar_criterios(self):
        """Rearma los iteradores del criterio"""
        self.iterador_criterio = {}
        self.lista_criterio.clear()
        for criterio in self.criterios:
            self.iterador_criterio[criterio] = self.lista_criterio.append(
                    [criterio])
    
    def quitar_secuencia(self, widget):
        """Elimina una secuencia de ordenamiento de la lista"""
        pos, seleccionado = self.criterio_seleccionado(self.tree_secuencia)
        if seleccionado:
            criterio = self.secuencia[pos]
            self.criterios.append(criterio)
            self.iterador_criterio[criterio] = self.lista_criterio.append(
                    [criterio])
            self.lista_secuencia.remove(self.iterador_secuencia[criterio])
            self.secuencia.remove(criterio)
            self.rearmar_secuencia()

        else:
            texto = ["Debe seleccionar el criterio que quiere quitar de la",
                    "lista de Secuencia de Ordenamiento."]
            msj = MensajeDeError("\n".join(texto), self.window)
            msj.run()
    
    def rearmar_secuencia(self):
        """Rearma los iteradores de la lista de secuencia de ordenamiento"""
        self.iterador_secuencia = {}
        self.lista_secuencia.clear()
        for criterio in self.secuencia:
            self.iterador_secuencia[criterio] = self.lista_secuencia.append(
                    [criterio])

    def imprimir_en_consola(self):
        print "Datos para el filtrado de datos"
        print "Agrupados por: "
        if self.radio_ascendente.get_active():
            orden = "Ascendente"
        else:
            orden = "Descendente"
        print "En forma: %s" % orden
        print "Ordenados con la secuencia: "
        print self.secuencia


    def configurar_reporte(self, widget):
        """cuak!"""
        if self.datos_validos():
            self.imprimir_en_consola()
            #!!!FIXME
            print "De onda SQLObject no tiene un groupBy :S"
            if self.radio_ticket.get_active():
                self.visualizar_resultado_ticket()
        else:
            texto = "Secuencia de ordenamiento no puede ser vacia"
            msj = MensajeDeError(texto, self.window)
            msj.run()

    def datos_validos(self):
        if self.secuencia or self.radio_ticket.get_active():
            return True
        else:
            return False

    def visualizar_resultado_ticket(self):
        """Permitira emitir el resultado correcto para el CDU20.
        Este caso de uso muestra los datos en orden ascendente o descendente
        """
        if self.radio_ascendente.get_active():
            tickets = Ticket.select()
            texto = ('Agrupados por: TICKET en forma: ASCENDENTE\n' +
                    '-------------------------------------------\n')
        else:
            tickets = Ticket.select(orderBy=DESC(Ticket.q.id))#aca ira .numero
            texto = 'Agrupados por: TICKET en forma: DESCENDENTE'
        """
        self.lista_resultado = gtk.ListStore(str, str, str, str,
                str, str, str, str, str)
        titulos = ("Nro.\nticket", "Clasificación\nactual", "Estado\nactual",
                "Tiempo acumulado\nde atención", "Grupo de\nresolución",
                "Tiempo real\nde atención", "Tiempo total\nasignado",
                "Reclasificaciones", "Fecha de\nreclasificación")
        for pos, titulo in enumerate(titulos):
            add_find_column(titulo, pos, self.tree_resultado)
        self.tree_resultado.set_model(self.lista_resultado)
        """
        self.mostrar_resultado(tickets, texto)
        # Ocultamos las cajas que no sirven y mostramos las que si
        self.vbox_62.hide()
        #self.hbox_116.show()
        self.hbox_110.show()
        self.window.resize(700, 600)
        #self.selection = self.tree_resultado.get_selection()
        #self.selection.connect("changed", self.mostrar_usuario_seleccionado)

    def mostrar_usuario_seleccionado(self):
        """Mostrará los datos del usuario del ticket seleccionado"""
        model, paths = self.selection.get_selected_rows()
        if paths:
            pass
    
    def mostrar_resultado(self, tickets, texto):
        """Arma la vista de resultado"""
        tiempo_acumulado = 'nino'
        tiempo_real = 'nino'
        tiempo_total_asignado = 'nino'
        for ticket in tickets:
            print type(ticket.id)
            texto+=("Ticket: %d\n \
                    \tEstado actual: %s\n \
                    \tClasificacion actual: %s\n \
                    \tTiempo acumulado total de atencion: %s\n \
                    \tGrupo de Resolucion: %s\n\
                    \t\tLegajo: %s\n \
                    \t\tNombre: %s\n \
                    \t\tApellido: %s\n") % (ticket.id,
                    ticket.historial_de_estado[-1].estado.nombre,
                    ticket.historial_de_clasificacion[-1].clasificacion.nombre,
                    tiempo_acumulado,
                    ticket.grupo_de_resolucion.nombre,
                    ticket.usuario_creacion.empleado.legajo,
                    ticket.usuario_creacion.empleado.nombre,
                    ticket.usuario_creacion.empleado.apellido)
        self.wTree.get_widget("textview22").get_buffer().set_text(texto)

    def close(self, widget):
        close(self.window)

    def aceptar(self, widget):
        self.window.destroy()

    def imprimir(self, widget):
        pass

    def detalle_ticket(self, widget):
        pass




